
3 Environment

=================================================

Implementation Guide

Processor		68000	x64	x86	 8086	  Z80
============		======	=======	======== =======  ========		
AVAIL			A4	RDI	EDI	 DI	  DE
VECP			A2	R8	G:VecP	 G:VecP	  G:VecP
DICP			A3	R9	G:DicP	 G:DicP	  G:DicP
SYMPC			A5	RSI	ESI	 SI	  IX
FRAMEP			A6	RBP	EBP	 BP	  HL
SP			A7	RSP	ESP	 SP	  SP

INCODE			D5	R10	G:Incode G:Incode G:Incode
SYMSTR			D6	R11	G:SymStr G:SymStr G:SymStr
GLBLFP			D7	RDX	EDX	 DX	  IY

Free			D0-D3	RAX-RCX	EAX-ECX	 AX,BX,CX A-C
			A0-A1	R12-15	

Vector Elt Lengths
Double 			64	64	64	 32	  32
Long			32	32	32	 16	  16
Word			16	16	16	 16	  16
Byte			 8 	 8	 8	  8	   8

Stack-Width		32	64	32	 16	  16
Pointer Size		32	64	32	 16	  16

Scalars 		32	64	32	 16	  16
$ lit stk elts trunc to 16	 8	 8	  8	   8

===================================================================

6 Scanloops: 
	Main (never ends)
	Name-end (CTL , ? ` ;: {} ^ % \ @ ' $ # SP ends)
		( ) _ 0-9 + - [ ] < > = / * & ! | . a-z A-Z do not end)
	Charlit (' cr end buffer ends), 
 	Scalarlit (0-9 a-f A-F ok, else ends)
	Hexlit ($ ends) 
	Declit (0-9 ok, else ends)

Executing off the end of a code function body is impossible because the 
interpretor supplies a gratuitous return at the end incase the user forgot it.

Interpreting off the end of a symbolic function body (or character literal@ used
as one inline, or include file) will cause the interpretor to attempt to do 
something useful but will generally NOT be what you want. The 3 language
does NOT purport to support symbolic functions whose bodies are split across
the boundary of multiple include files.

Do not have last character in a character literal used via @ as an inlined 
sym function, or in a sym function itself, or in an included file, be the first 
character of an operator that could have additional characters, i.e.
" (which could be beginning of "d or "? or "?d), because the interpretor
will try to peek a character ahead to see what the next character is,
and the scan for the next character will encounter the end of the body 
and trigger the undesired behavior above.  You should always follow an operator
at the end of a body with a space.

For the same reasons you should not end with a } because the interpretor
will try to figure out whether it is a }} with a peek ahead scan.

Also note that the interpretor peeks one character backwards when handling }
unmark characters to determine whether the token is the trailing } in 
{%} {} or {~}. The interpretor implements these operators by backing up the scanner
to refetch portions of the token if the terminating condition is not met when the
right brace is encountered.

=======================================================================

Operators: (1-3 character invocations detected in main interpretor and 
	jumped to, not called)

$ 	Code Function Body Delimiter Operator - begins and ends assembling words to stack;
	Full interpretor expressions are available at assembly time 
	but words pushed to stack execute when the function is 
	invoked by a call at run time
	
$$ 	(starts and ends the minimum code function possible with a single return 
	instruction as the code function body)

# 	Hexadecimal Scalar Start Operator - hex constant longword pushed to stack
	ends at 1st non hex digit; value zero if no hex digits
	## is just two consecutive #'s one with value 0 then the next one

' 	Character Literal Delimiter Operator begins and ends 
	character literals. The interpretor scans characters to stack for 
	character literals or sym function bodies; 
	no expr eval during scan except \ escs
	single null appended at end

'' 	creates a byte vector consisting of a single null byte

@ 	namecall while interpreting, @@ is two consecutive @'s


\ 	Escape/Comment Start Operator - Starts escaped special character,
	hexcoded byte or to ignore CR or NUL in character literal.
	Starts ignore to eol if not in character literal.

	  \ escapes in character literals:
		\\   encode a back slash \
		\'   encode a right quote character '
		\<cr>  encode nothing, allows user to type lits > 1 line
		\x or \xx or \yxx encode bytes with values $0x, $xx, $xx
			(more than two hex digits overflow to left)
		\<nul> encode nothing


%	Value Call (Invoke) Operator - Evaluates the quantity whose dictionary entry
	(dicent) or name is in tos. Value of a scalar is the scalar. Value of 
	a data vector or its name (whatever the element size) is the vector pointer. Value of
	a function vector or function name is determined by invoking that code or
	symbolic function.
	
%%	two consecutive %s. This permits a function to return the name of
	another function which can be called via the second %.

` 	Indirect Call Operator - call through tos if interpreting or if assembling
	
`` 	compile call through tos if assembling, else just two consecutive `s
	Two consecutive `s would be used to invoke a function via an indirect call which returned 
	the pointer to another function's entry point suitable for indirect call via the second `.

"	Unconditional Return Operator - (RESULT) = tos; return from current symbolic function, 
	character literal or include file being
	interpreted.  If assembling this assembles result = tos;return code to stack for current code
	function body.	"" is two consecutive 's

"d	Double Unconditional Return Operator - (RESULT+LNGBYTS) = tos-1;(RESULT)=tos;
	return from symfn if interpreting;
	assembles similar code to stk if assembling

"?	Return If Non-Zero Operator - based on Boolean in tos 
	if tos non-zero then (RESULT)=tos-1; return else drop; drop endif
	assembles similar code to stk if assembling

"?d	Double Return if Non-Zero Operator - based on bool in tos	
	if tos then (RESULT+LNGBYTS)=tos-2;(RESULT)=tos-1;return 
	else drop;drop;drop endif
	assembles similar code to stk if assembling

"~	Return If Zero Operator - based on Boolean in tos 
	if tos zero then (RESULT)=tos-1; return else drop; drop endif
	assembles similar code to stk if assembling

"~d	Double Return if Zero Operator - based on bool in tos
	if tos zero then (RESULT+LNGBYTS)=tos-2;(RESULT)=tos-1;return 
	else drop;drop;drop endif
	assembles similar code to stk if assembling

^ 	Indirect Indexed Jump Operator - jumps to current symbolic function byte 
	indexed in tos if interpreting; 
	assembles code to jump to code word w/ index in tos at runtime 
	if assembling. 	

	Only works within current buffer in included file or 
	interactively with user.

^^	Indirect Absolute Jump Operator - jumps to absolute address in tos if interpreting;
	assembles code to jump to absolute address in tos if assembling

? 	Indirect Indexed Jump If Non-Zero Operator - jump through tos-1 index if tos 
	non-zero if interpreting;
	assembles code to jump to tos-1 index if tos non-zero at runtime 
	if assembling. 

	Only works within current buffer in included file or 
	interactively with user!

??	Indirect Absolute Jump Operator - jumps through absolute address in tos-1 
	if tos non-zero if interpreting;
	assembles code to jump through absolute address in tos-1 if tos non-zero at
	runtime if assembling
	
: 	Label Index Operator - pushes index in current vector for label in fns, 

	Explanation of how label-defining : and goto ^ work:

	Defining a label:
	{ {_VecLast `} 'label1' _SCALAR : _DicNew` } 
			 \ defines scalar label1 with value of cur ix in bincodvec
	...			\ ...intervening code...
	label1 ^	\ invokes label1 which pushes the ix value from the scalar
			\ and then ^ operator computes addr of ixth word in code
			\ using VecEltI (code vecptr is put in result slot of
			\ code fn when it is invoked so it can be used to 
			\ replace ix by address of the actual code byte,
			\ then it is jumped to directly

			\ For fwd ref lbls must define lbl1 first, then
			\ use _DicSetScalVecP to update it when get to correct : locn
			\ else label1 becomes anonymous chlit when 1st encountered!

	either exits w/ body result as before or as opt. stored
	or continues w/ fresult * val fresult in tos for possible future use.

::	Local Address Operator - pushes address of tos-th local
	tos is left shifted 2 bits to convert longwords to bytes, then 
	has current contents of framepointer added to it

	Example: to load 3rd local:  3 :: [_`
	Example: to store v to 2nd local:  2 :: v _[`
	Pushes similar code to stack if assembling.
	
;]	The three Conditional Function Execution Operators follow. They
:[	expect their single argument (or two arguments) to be
:?	namecalls of symbolic functions, namecalls of character literals,
	namecalls of character vectors, namecalls of scalars, or namecalls
	of scalar literals.  The operators are bracketed by mark/unmark as 
	shown below, but the operands may precede the mark if the 
	undermark operator {: is used as below. The operator is 
	called as an operator, not via a left quote ` operator.  
	Their arguments are dic ents, not vec ptrs.


;]	If-Then Call Operator		   	            <chlit@/symfn> <bool> {: :]}

:[	Unless Call Operator		   	            <chlit@/symfn> <bool> {: :[}

:?	If-Then-Else Call Operator  <then chlit#/symfn><else chlit#/symfn> {: <bool> :?}
 	
:}	Case Branch Operator

	Usage:   
	{ fn1@  matchval1 fn2@ matchval2 fn3@ matchval3 ...fni@ matchvali val i :}

	Mark, then push i pairs of fn@ matchvals, then test val, then count i, the :}
	Returns -1 if no matchval matches, else returns {fnj} for function in pair
	whose matchj == val.

@}	Indexed Branch Operator

	Usage:
	{ fni-1@ ... fn0@ inxexpr i %}

	Mark, then push i fn@ dicents, then inexpr, then count i %}
	Returns -1 if inexpr value j not in range 0..i-1 else returns {fnj}. 

;	Breakpoint Exchange Operator - if interpreting then read word from (tos-1), 
	replace with loworder word 
	from tos-- return word read used to set a breakpoint by pushing target
	addr then a TRAP #14 instruction used to restore a breakpoint by pushing
	target addr then the saved instruction
	(The pre-defined symbols include _PrtDbg which is a trap handler, and 
	_PrtBrk which is a TRAP #14 instruction and _PrtNop which is a no-op.  
	IF the code is NOT in read-only memory then you can set a breakpoint at 
	address foo by { #b8 _PrtDbg { _[_ `}} \ set exception vector for Trap #14 
	to point to _PrtDbg

        _PrtNop		\ use _PrtNop to hold breakpointed instruction
	foo _PrtBrk { _[w `}; \ ; called with the TRAP #14 from _PrtBrk to be 
			\ swapped with instr at foo
	{ _[_w `}}	\ store the returned instr from foo at _PrtNop
	}}		\ _PrtDbg will back up the PC from the trap, 
			\ restore the instr from _PrtNop and
			\ continue after displaying the status register and 
			\ trapped PC like this
			\   $2000;000045C0   and then accepting any key to continue

; 	Indirect Call to Assemble Operator - if assembling acts as ` but has code 
	compiled to stack by function called
	rather than interpreted 

.	Include Operator - tos is chvecptr to filename, returns results of 
        interpreting included file if present else 
	return the file open error status; best surround w/ mark/unmark
	.. is two consecutive .'s

,	8-Element Stack Display Operator - prints space, 8 hex digits of tos without altering tos
	prints tos..tos-7 as space, 8 hex...

,,	16-Element Stack Display Operator - same as , but does second line with tos-8..tos-15 


{ 	Mark Operator - mark stack while interpreting
	compiles mark code to stk if assembling

{:	Undermark Operator - "undermark" while interpreting
	pop tos; pop tos; mark;repush;repush i.e. slips a mark under tos-1 and tos
	compiles undermark code to stk if assembling

	User can implement double undermark by #0, _[[, {:

{{	Mark Double Operator - assemble mark code to stk if assembling else treated 
	as mark for call to dbl function (pushes extra long for loworder result).

{} 	Repeat Indirect Call Until Non-Zero Operator - cycle invoke dicent in tos until true 
	dup, mark, rotu, backup sympc by 1 invoke dicent
	when dicent returns it will point to the } again
	when } executes as unmark it will check for { immediately preceding 
	and if found then if tos is false backup sympc so next interpreted 
	is this operator's {
    
{~} 	Repeat Indirect Call Until Zero Operator - cycle invoke dicent in tos until false
	dup, mark, rotu, backup sympc by 1 invoke dicent
	when dicent returns it will point to the } again
	when } executes as unmark it will check for {~ immediately preceding 
	and if found then if tos is true backup sympc so next interpreted 
	is this operator's {

{%} 	For Loop Indirect Call Operator - fn@ i {%}
	repeat fn(i); i=i-1 until i < 0
    
} 	Unmark Operator - unmark stack while interpreting, if immediately preceding char is { then
	backup sympc so {} loop operator loops


}}	Unmark and Drop Operator - assemble unmark code to stack if assembling else treat 
	as unmark drop

| 	Or Operator -  without a mark while interpreting

||	compile an or assuming no mark to stack if assembling
		
& 	And Operator - without a mark while interpreting

&& 	compile an and assuming no mark to stack if assembling

!	Exclusive Or Operator - without a mark while interpreting

!!	compile an exclusive or assuming no mark to stack if assembling

~	Complement Operator - 1's complement without a mark while interpreting

~~	compile a not assuming no mark to stack if assembling

+	Addition Operator - without a mark while interpreting

++	compile a plus assuming no mark to stack if assembling

-	Subtraction Operator - without a mark while interpreting

--	compile a minus assuming no mark to stack if assembling

* 	Multiplication Operator - unsigned 16x16 multiply without a mark while interpreting

**	compile an unsigned 16x16 multiply assuming no mark while interpreting

/ 	Division Operator - unsigned 32 divide by 16 -> rem:quotient without a mark while interpreting

//	compile an unsigned 32 / 16 ->r:q assuming no mark if assembling

) 	Logical Shift Right Operator - lsr tos-1 by cnt 0-8 in tos-- without a mark while interpreting

))	compile equivalent assuming no mark if assembling

( 	Logical Shift Left Operator - lsl tos-1 by cnt 0-8 in tos-- without a mark while interpreting

((	compile equivalent assuming no mark if assembling


========================================================================

Built-In Functions: 1+ character functions detected in interpreter and 
	invoked by jsr.	User is obliged to mark, and unmark, but these fns
	work "Under the mark" so that explicit parameters are not passed.
	Called via ` from interpretor for interpreted execution,
	via ; to request pushing equivalent code to stack 
	(remember that only loworder 16 of each 32 bit slot is assembled).

>| 	Arithmetic Shift Right Predefined Code Functon - asr tos-1 by cnt 0-8 in tos--
	works below the mark when called via ` interpreting, 
	quadruple fn called via ; assumes no mark and compiles equiv code to stk

<| 	Arithmetic Shift Left Predefined Code Functon - asl tos-1 by cnt 0-8 in tos--
	works below the mark when called via ` interpreting, 
	quadruple fn called via ; assumes no mark and compiles equiv code to stk

>)	Rotate Right Predefined Code Functon - ror tos-1 by cnt 0-8 in tos--
	works below the mark when called via ` interpreting, 
	quadruple fn called via ; assumes no mark and compiles equiv code to stk

<)	Rotate Left Predefined Code Function - rol tos-1 by cnt 0-8 in tos--
	works below the mark when called via ` interpreting, 
	quadruple fn called via ; assumes no mark and compiles equiv code to stk


d0[	Push Scratch Register Zero Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk
..
d4[	Push Scratch Register Four Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

INCODE[ Push INCODE Interpretor Register Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

SYMSTR[ Push SYMSTR Interpretor Register Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

GLBLFP[ Push GLBLFP Interpretor Register Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

RESULT[ Push RESULT from Current Stack Frame Predefined Code Function -
	push current result value for current fn (a6) into tos
	or compiles equivalent runtime code to stk

a0[	Push Scratch Address Register 0 Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

a1[	Push Scratch Address Register 1 Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

VECP[ 	Push VECP Interpretor Register Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

DICP[	Push DICP Interpretor Register Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

AVAILP[	Push AVAILP Interpretor Register Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

SYMPC[	Push SYMPC Interpretor Register Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

FP[	Push FP Interpretor Register Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

SP[ 	Push SP Interpretor Register Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

SR[	Push Implementation Status Register Predefined Code Function
	pushes SR long-extended to the stack
	works below the mark when called via ` interpreting,
	triple fn called via ; assumes no mark and compiles equiv code to stk

USP[	Push Implementation User Stack Pointer Register Predefined Code Function
	works below the mark when called via ` interpreting,
	dbl fn called via ; assumes no mark and compiles equiv code to stk

[d0	Pop Scratch Register 0 Predfined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

..
[d4	Pop Scratch Register 4 Predfined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

[INCODE	Pop INCODE Interpretor Register Predfined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

[SYMSTR Pop SYMSTR Interpretor Register Predfined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

[GLBLFP Pop GLBLFP Interpretor Register Predfined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

[RESULT Store TOS in Current Frame Result Predefined Code Function - 
	works below the mark when called via ` interpreting,
	called via ; assumes no mark and compiles equiv code to stk

[a0	Pop Scratch Address Register 0 Predefined Code Function - 
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

[a1	Pop Scratch Address Register 1 Predefined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

[VECP	Pop VECP Interpretor Register Predfined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

[DICP	Pop DICP Interpretor Register Predfined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

[AVAILP	Pop AVAILP Interpretor Register Predfined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

[SYMPC	Pop SYMPC Interpretor Register Predfined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

[FP	Pop FP Interpretor Register Predfined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

[SP	Pop SP Interpretor Register Predfined Code Function -
	works below the mark when called via ` interpreting, 
	called via ; assumes no mark and compiles equiv code to stk

[USP	Pop Implementation User Stack Pointer Predefined Code Function -
	works below the mark when called via ` interpreting, 
	double fn called via ; assumes no mark and compiles equiv code to stk

[SR	Pop Implementation Status Register Predefined Code Function -	
	works below the mark when called via ` interpreting, 
	double fn called via ; assumes no mark and compiles equiv code to stk

[CCR	Pop Implementation Condition Codes Predefined Code Function -
	works below the mark when called via ` interpreting, 
	double fn called via ; assumes no mark and compiles equiv code to stk


_[_	Long Store Indirect Predefined Code Function - store long tos-- through tos-1
	works below the mark when called via ` interpreting, 
	triple fn called via ; assumes no mark and compiles equiv code to stk

_[_w	Word Store Indirect Predefined Code Function - store word tos-- through tos-1	
	works below the mark when called via ` interpreting, 
	triple fn called via ; assumes no mark and compiles equiv code to stk

_[_b	Byte Store Indirect Predefined Code Function - store byte tos-- through tos-1
	works below the mark when called via ` interpreting, 
	triple fn called via ; assumes no mark and compiles equiv code to stk

_[	Long Value Call Indirect Predefined Code Function - long replace tos by (tos)
	works below the mark when called via ` interpreting, 
	double fn called via ; assumes no mark and compiles equiv code to stk

_[w	Word Value Call Indirect Predefined Code Function - word replace tos by (tos)
	works below the mark when called via ` interpreting, 
	quadruple fn called via ; assumes no mark and compiles equiv code to stk

_[b	Byte Value Call Indirect Predefined Code Function -byte replace tos by (tos)
	works below the mark when called via ` interpreting, 
	quadruple fn called via ; assumes no mark and compiles equiv code to stk

[]	Subscript Predefined Code Function  - index in tos, dicent in tos-1, returns 
	@elt i of dicent's vector
	if dicent is scalar just returns scalar value
	returns null if dicent null, scalar zero, vector null, or i not in 0..curinx
	same compiling or interpreting, works below the mark, called via `

[[	Duplicate Predefined Code Function - 
	works below the mark when called via ` interpreting, 
	single fn called via ; assumes no mark and compiles equiv code to stk

[[><	Duplicate and Word Swap Predefined Code Function - dupswap
	works below the mark when called via ` interpreting, 
	triple fn called via ; assumes no mark and compiles equiv code to stk

[[[[	Double Duplicate Predefined Code Function -
	works below the mark when called via ` interpreting, 
	double fn called via ; assumes no mark and compiles equiv code to stk

[[[[[[	Triple Dumplicate Predefined Code Function -
	works below the mark when called via ` interpreting, 
	triple fn called via ; assumes no mark and compiles equiv code to stk

][	Exchange Predefined Code Function - 
	works below the mark when called via ` interpreting, 
	quad fn called via ; assumes no mark and compiles equiv code to stk

[_	Drop Predefined Code Function - 
	works below the mark when called via ` interpreting, 
	DO NOT CALL IF LAST PRIOR MARK wholly or partially in dropped slot
	double fn called via ; assumes no mark and compiles equiv code to stk

[__	Double Drop Predefined Code Function -
	works below the mark when called via ` interpreting,
	DO NOT CALL IF LAST PRIOR MARK wholly or partially in the dropped slots
	single fn called via ; assumes no mark and compile equiv code to stk

_[[	Rotate Down Predefined Code Function - 
	works below the mark when called via ` interpreting, 
	hexuple fn called via ; assumes no mark and compiles equiv code to stk

[[_	Rotate Up Predefined Code Function - 
	works below the mark when called via ` interpreting, 
	hexuple fn called via ; assumes no mark and compiles equiv code to stk

[[__	Double Exchange Predefined Code Function -
	exchanges top two doubles on stack
	works below the mark when called via ` interpreting, 
	14-uple fn called via ; assumes no mark and compiles equiv code to stk


_xw	Sign Extend Word Predefined Code Function - sign extend tos word to long
	works below the mark when called via ` interpreting, 
	triple fn called via ; assumes no mark and compiles equiv code to stk

_xb	Sign Extend Byte Predefined Code Function - sign extend tos byte to long
	works below the mark when called via ` interpreting, 
	triple fn called via ; assumes no mark and compiles equiv code to stk

=+	Increment Predefined Code Function - add 1 to tos
	works below the mark when called via ` interpreting, 
	triple fn called via ; assumes no mark and compiles equiv code to stk

=-	Decrement Predefined Code Function - subtract 1 from tos
	works below the mark when called via ` interpreting, 
	triple fn called via ; assumes no mark and compiles equiv code to stk

<= 	Less Equal Predefined Code Function - less equal
	works below the mark when called via ` interpreting, 
	octuple fn called via ; assumes no mark and compiles equiv code to stk

<>	Not Equal Predefined Code Functon - not equal
	works below the mark when called via ` interpreting, 
	octuple fn called via ; assumes no mark and compiles equiv code to stk

>=	Greater Equal Predefined Code Function - greater equal
	works below the mark when called via ` interpreting, 
	octuple fn called via ; assumes no mark and compiles equiv code to stk

==	Equal Predefined Code Function - equal
	works below the mark when called via ` interpreting, 
	octuple fn called via ; assumes no mark and compiles equiv code to stk

<<	Less Than Predefined Code Function - less than
	works below the mark when called via ` interpreting, 
	octuple fn called via ; assumes no mark and compiles equiv code to stk

>>	Greater Than Predefined Code Function - greater than
	works below the mark when called via ` interpreting, 
	octuple fn called via ; assumes no mark and compiles equiv code to stk

><	Word Swap Predefined Code Function - tos word swap
	works below the mark when called via ` interpreting, 
	triple fn called via ; assumes no mark and compiles equiv code to stk
